1. Field of the Invention
The invention concerns interactive programming tools generally and more specifically concerns interactive program debuggers.
2. Description of the Prior Art
Debuggers are tools used by programmers to determine what is going on when a program is executed. A debugger typically permits a programmer to start and stop the program's execution and to examine the state of the memory (including hardware registers) being used by the program. Modern debuggers are interactive: that is, a programmer can input a command to the debugger and see the effects of the command within a relatively short period of time. Modern debuggers can further relate what the programmer does and sees to the source code for the program being debugged. Thus, if the programmer wants to examine the contents of a certain variable, he or she can select the variable by name and the debugger will show the programmer the contents in a form that corresponds to the type of the variable. Similarly, a trace of calls to subroutines made by the program and returns therefrom will display the names of the subroutines being called and returned to. Two examples of state-of-the-art debuggers are the BoundsChecker™, manufactured by Compuware Corporation, and Purify, manufactured by Rational Software. Further information about BoundsChecker may be found at www.numega.com/library/doc.shtml, which in October, 1998 contained the complete documentation for the debugger. Further information about Purify could be found in October, 1998 at www.rational.com/support/techpapers. In addition, the Purify debugger is the subject matter of U.S. Pat. No. 5,535,329, Reed Hastings, Method and apparatus for modifying relocatable object code files and monitoring programs, issued Jul. 9, 1996. A general discussion of debuggers may be found in Jonathan B. Rosenberg, How Debuggers Work, Algorithms, Data Structures, Architecture, Wiley 1996.
While any modern debugger is useful, debuggers would be more useful if they offered more flexible user interfaces. As it stands, debuggers have two ways of providing the user with information: by means of a proprietary interactive user interface which communicates directly with the debugger as it executes the program and by means of a log file, that is, a text file which contains a list of the interactions between the user and the debugger. Problems with this arrangement include first, that the interactive user interface can only be used to analyze the current execution of the program; information about past executions is contained in the log file, and that requires other tools to read it. A second problem is that the proprietary user interface requires that the user interacting with the debugger have the interface software and also limits the user to the kind of interaction dictated by the proprietary user interface. As for the log files, nothing can be done with the log file beyond what is usually done with text files.
One consequence of the use of proprietary user interfaces is that debuggers have not taken advantage of the standard graphical user interfaces that have lately evolved. In particular, they have not been adapted to work with Web browsers, and that in turn means not only that the programmer must use a less-convenient user interface than that provided by the his or her Web browser, but also that a progranmer who wants to debug a program that is running on a remote machine cannot use the Web browser and the Internet to do the debugging, but must instead have a special connection to the remote machine which permits the programmer to use the proprietary interface.
What is needed, then, is a debugger which may be easily adapted to a number of different kinds of user interfaces, including the user interface provided by Web browsers and that works as well to analyze information about past executions of a program as it does to analyze information about a current execution. It is an object of the present invention to provide such a debugger.